export const AssembleData = [
    {
        key: 1,
        name: "countBy",
        remark: "返回一个对象，key是处理数组的结果，value是次数",
        use: "_.countBy(collection, [iteratee=_.identity])",
        description: "创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数（注：迭代次数）。 iteratee 调用一个参数：(value)。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 一个迭代函数，用来转换key（键）。
        `,
        return: "(Object): 返回一个组成集合对象。",
        case: `
_.countBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': 1, '6': 2 }
 
// The _.property iteratee shorthand.
_.countBy(['one', 'two', 'three'], 'length');
// => { '3': 2, '5': 1 }       
        `,
    },
    {
        key: 2,
        name: "forEach【别名_.each】",
        remark: "遍历每一个元素执行function",
        use: "_.forEach(collection, [iteratee=_.identity])",
        description:
            "调用 iteratee 遍历 collection(集合) 中的每个元素， iteratee 调用3个参数： (value, index|key, collection)。 如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。注意: 与其他'集合'方法一样，类似于数组，对象的 'length' 属性也会被遍历。想避免这种情况，可以用_.forIn 或者_.forOwn 代替。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Function): 每次迭代调用的函数。
        `,
        return: "(*): 返回集合 collection。",
        case: `
_([1, 2]).forEach(function(value) {
  console.log(value);
});
// => Logs 1 then 2.
 
_.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
  console.log(key);
});
// => Logs 'a' then 'b' (iteration order is not guaranteed).        
        `,
    },
    {
        key: 3,
        name: "forEachRight",
        remark: "遍历每一个元素执行function，从末尾开始",
        use: "_.forEachRight(collection, [iteratee=_.identity])",
        description: "这个方法类似_.forEach，不同之处在于，_.forEachRight 是从右到左遍历集合中每一个元素的。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Function): 每次迭代调用的函数。
        `,
        return: "(*): 返回集合 collection。",
        case: `
_.forEachRight([1, 2], function(value) {
  console.log(value);
});
// => Logs 2 then 1.       
        `,
    },
    {
        key: 4,
        name: "every",
        remark: "对数组进行处理查看是否每一项都符合迭代器规则",
        use: "_.every(collection, [predicate=_.identity])",
        description:
            "通过 predicate（断言函数） 检查 collection（集合）中的 所有 元素是否都返回真值。一旦 predicate（断言函数） 返回假值，迭代就马上停止。predicate（断言函数）调用三个参数： (value, index|key, collection)。注意: 这个方法对于对于空集合返回 true，因为空集合的任何元素都是 true 。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(boolean): 如果所有元素经 predicate（断言函数） 检查后都都返回真值，那么就返回true，否则返回 false 。",
        case: `
_.every([true, 1, null, 'yes'], Boolean);
// => false
 
var users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
// The _.matches iteratee shorthand.
_.every(users, { 'user': 'barney', 'active': false });
// => false
 
// The _.matchesProperty iteratee shorthand.
_.every(users, ['active', false]);
// => true
 
// The _.property iteratee shorthand.
_.every(users, 'active');
// => false       
        `,
    },
    {
        key: 5,
        name: "filter",
        remark: "遍历数组返回符合迭代器规则的数据",
        use: "_.filter(collection, [predicate=_.identity])",
        description: "遍历 collection（集合）元素，返回 predicate（断言函数）返回真值 的所有元素的数组。 predicate（断言函数）调用三个参数：(value, index|key, collection)。Note: Unlike_.remove, this method returns a new array.",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回一个新的过滤后的数组",
        case: `
var users = [
  { 'user': 'barney', 'age': 36, 'active': true },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
_.filter(users, function(o) { return !o.active; });
// => objects for ['fred']
 
// The _.matches iteratee shorthand.
_.filter(users, { 'age': 36, 'active': true });
// => objects for ['barney']
 
// The _.matchesProperty iteratee shorthand.
_.filter(users, ['active', false]);
// => objects for ['fred']
 
// The _.property iteratee shorthand.
_.filter(users, 'active');
// => objects for ['barney']       
        `,
    },
    {
        key: 6,
        name: "find",
        remark: "遍历集合找到符合条件的项",
        use: "_.find(collection, [predicate=_.identity], [fromIndex=0])",
        description: "遍历 collection（集合）元素，返回 predicate（断言函数）第一个返回真值的第一个元素。predicate（断言函数）调用3个参数： (value, index|key, collection)。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
3.[fromIndex=0] (number): 开始搜索的索引位置。
        `,
        return: "(*): 返回匹配元素，否则返回 undefined。",
        case: `
var users = [
  { 'user': 'barney',  'age': 36, 'active': true },
  { 'user': 'fred',    'age': 40, 'active': false },
  { 'user': 'pebbles', 'age': 1,  'active': true }
];
 
_.find(users, function(o) { return o.age < 40; });
// => object for 'barney'
 
// The _.matches iteratee shorthand.
_.find(users, { 'age': 1, 'active': true });
// => object for 'pebbles'
 
// The _.matchesProperty iteratee shorthand.
_.find(users, ['active', false]);
// => object for 'fred'
 
// The _.property iteratee shorthand.
_.find(users, 'active');
// => object for 'barney'       
        `,
    },
    {
        key: 7,
        name: "findLast",
        remark: "从右到左进行遍历符合预期的项",
        use: "_.findLast(collection, [predicate=_.identity], [fromIndex=collection.length-1])",
        description: "这个方法类似_.find ，不同之处在于，_.findLast是从右至左遍历collection （集合）元素的。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
3.[fromIndex=collection.length-1] (number): 开始搜索的索引位置。
        `,
        return: "(*): 返回匹配元素，否则返回 undefined。",
        case: `
_.findLast([1, 2, 3, 4], function(n) {
  return n % 2 == 1;
});
// => 3
        `,
    },
    {
        key: 8,
        name: "flatMap",
        remark: "对数组进行遍历处理后扁平化合并",
        use: "_.flatMap(collection, [iteratee=_.identity])",
        description: "创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且扁平化合并。 iteratee 调用三个参数： (value, index|key, collection)。",
        argument: `
1.collection (Array|Object): 一个用来迭代遍历的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回新扁平化数组。",
        case: `
function duplicate(n) {
  return [n, n];
}

_.flatMap([1, 2], duplicate);
// => [1, 1, 2, 2]
        `,
    },
    {
        key: 9,
        name: "flatMapDeep",
        remark: "类似_.flatMap 不同之处在于，_.flatMapDeep 会继续扁平化递归映射的结果。",
        use: "_.flatMapDeep(collection, [iteratee=_.identity])",
        description: "这个方法类似_.flatMap 不同之处在于，_.flatMapDeep 会继续扁平化递归映射的结果。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回新扁平化数组。",
        case: `
function duplicate(n) {
  return [[[n, n]]];
}

_.flatMapDeep([1, 2], duplicate);
// => [1, 1, 2, 2]
        `,
    },
    {
        key: 10,
        name: "flatMapDepth",
        remark: "类似_.flatMap，不同之处在于，_.flatMapDepth 会根据指定递归深度继续扁平化递归映射结果。",
        use: "_.flatMapDepth(collection, [iteratee=_.identity], [depth=1])",
        description: "该方法类似_.flatMap，不同之处在于，_.flatMapDepth 会根据指定的 depth（递归深度）继续扁平化递归映射结果。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
3.[depth=1] (number): 最大递归深度。
        `,
        return: "(Array): 返回新扁平化数组。",
        case: `
function duplicate(n) {
  return [[[n, n]]];
}

_.flatMapDepth([1, 2], duplicate, 2);
// => [[1, 1], [2, 2]]
        `,
    },
    {
        key: 11,
        name: "forEach",
        remark: "遍历集合的元素执行处理",
        use: "_.forEach(collection, [iteratee=_.identity])",
        description:
            "调用 iteratee 遍历 collection(集合) 中的每个元素， iteratee 调用3个参数： (value, index|key, collection)。 如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。注意: 与其他'集合'方法一样，类似于数组，对象的 'length' 属性也会被遍历。想避免这种情况，可以用_.forIn 或者_.forOwn 代替。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Function): 每次迭代调用的函数。
        `,
        return: "(*): 返回集合 collection。",
        case: `
_([1, 2]).forEach(function(value) {
  console.log(value);
});
// => Logs 1 then 2.
 
_.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
  console.log(key);
});
// => Logs 'a' then 'b' (iteration order is not guaranteed).        
        `,
    },
    {
        key: 12,
        name: "forEachRight",
        remark: "遍历集合的元素执行处理，从右到左",
        use: "_.forEachRight(collection, [iteratee=_.identity])",
        description: "这个方法类似_.forEach，不同之处在于，_.forEachRight 是从右到左遍历集合中每一个元素的。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Function): 每次迭代调用的函数。
        `,
        return: "(*): 返回集合 collection。",
        case: `
_.forEachRight([1, 2], function(value) {
  console.log(value);
});
// => Logs 2 then 1.        
        `,
    },
    {
        key: 13,
        name: "groupBy",
        remark: "创建一个对象循环执行每一项，将执行结果相同的项作为key，每个元素项是value",
        use: "_.groupBy(collection, [iteratee=_.identity])",
        description: "创建一个对象，key 是 iteratee 遍历 collection(集合) 中的每个元素返回的结果。 分组值的顺序是由他们出现在 collection(集合) 中的顺序确定的。每个键对应的值负责生成 key 的元素组成的数组。iteratee 调用 1 个参数： (value)。",
        argument: `
1.collection (Array|Object): 一个用来迭代的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 这个迭代函数用来转换key。
        `,
        return: "(Object): 返回一个组成聚合的对象。",
        case: `
_.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }
 
// The _.property iteratee shorthand.
_.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }        
        `,
    },
    {
        key: 14,
        name: "includes",
        remark: "检查集合里面是否存在目标value，最后一个参数是检索开始位置",
        use: "_.includes(collection, value, [fromIndex=0])",
        description:
            "检查 value(值) 是否在 collection(集合) 中。如果 collection(集合)是一个字符串，那么检查 value（值，子字符串） 是否在字符串中， 否则使用SameValueZero 做等值比较。 如果指定 fromIndex 是负数，那么从 collection(集合) 的结尾开始检索。",
        argument: `
1.collection (Array|Object|string): 要检索的集合。
2.value (*): 要检索的值。
3.[fromIndex=0] (number): 要检索的 索引位置。
        `,
        return: "(boolean): 如果找到 value 返回 true， 否则返回 false。",
        case: `
_.includes([1, 2, 3], 1);
// => true

_.includes([1, 2, 3], 1, 2);
// => false

_.includes({ 'user': 'fred', 'age': 40 }, 'fred');
// => true

_.includes('pebbles', 'eb');
// => true
        `,
    },
    {
        key: 15,
        name: "invokeMap",
        remark: "为集合里面的每个元素执行函数，第二个参数是执行的函数，第三个是函数所调用的参数",
        use: "_.invokeMap(collection, path, [args])",
        description:
            "调用path（路径）上的方法处理 collection(集合)中的每个元素，返回一个数组，包含每次调用方法得到的结果。任何附加的参数提供给每个被调用的方法。如果methodName（方法名）是一个函数，每次调用函数时，内部的 this 指向集合中的每个元素。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.path (Array|Function|string): 用来调用方法的路径 或 者每次迭代调用的函数。
3.[args] (...*): 调用每个方法的参数。
        `,
        return: "(Array): 返回的结果数组。",
        case: `
_.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
// => [[1, 5, 7], [1, 2, 3]]

_.invokeMap([123, 456], String.prototype.split, '');
// => [['1', '2', '3'], ['4', '5', '6']]
        `,
    },
    {
        key: 16,
        name: "keyBy",
        remark: "对每个元素进行处理返回一个object，key是处理后的结果，value是生成key的最后一个元素",
        use: "_.keyBy(collection, [iteratee=_.identity])",
        description: "创建一个对象组成， key（键） 是 collection（集合）中的每个元素经过 iteratee（迭代函数） 处理后返回的结果。 每个 key（键）对应的值是生成key（键）的最后一个元素。iteratee（迭代函数）调用1个参数：(value)。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 这个迭代函数用来转换key。
        `,
        return: "(Object): 返回一个组成聚合的对象。",
        case: `
var array = [
  { 'dir': 'left', 'code': 97 },
  { 'dir': 'right', 'code': 100 }
];

_.keyBy(array, function(o) {
  return String.fromCharCode(o.code);
});
// => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }

_.keyBy(array, 'dir');
// => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
        `,
    },
    {
        key: 17,
        name: "map",
        remark: "对集合的每个元素进行处理，结果放入数组进行返回",
        use: "_.map(collection, [iteratee=_.identity])",
        description: `创建一个数组， value（值） 是 iteratee（迭代函数）遍历 collection（集合）中的每个元素后返回的结果。 iteratee（迭代函数）调用3个参数：
            (value, index | key, collection).

lodash 中有许多方法是防止作为其他方法的迭代函数（注：即不能作为iteratee参数传递给其他方法），例如：_.every, _.filter, _.map, _.mapValues, _.reject, 和_.some。

        受保护的方法有（注：即这些方法不能使用_.every, _.filter, _.map, _.mapValues, _.reject, 和_.some作为 iteratee 迭代函数参数） ：
        ary, chunk, curry, curryRight, drop, dropRight, every, fill, invert, parseInt, random, range, rangeRight, repeat, sampleSize, slice, some, sortBy, split, take, takeRight, template, trim, trimEnd, trimStart, and words`,
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[iteratee=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回新的映射后数组。",
        case: `
function square(n) {
  return n * n;
}
 
_.map([4, 8], square);
// => [16, 64]
 
_.map({ 'a': 4, 'b': 8 }, square);
// => [16, 64] (iteration order is not guaranteed)
 
var users = [
  { 'user': 'barney' },
  { 'user': 'fred' }
];
 
// The _.property iteratee shorthand.
_.map(users, 'user');
// => ['barney', 'fred']
        `,
    },
    {
        key: 18,
        name: "orderBy",
        remark: "对对象属性进行指定规则进行排序（可以先按name再对age排序）",
        use: "_.orderBy(collection, [iteratees=[_.identity]], [orders])",
        description: "此方法类似于_.sortBy，除了它允许指定 iteratee（迭代函数）结果如何排序。 如果没指定 orders（排序），所有值以升序排序。 否则，指定为'desc' 降序，或者指定为 'asc' 升序，排序对应值。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[iteratees=[_.identity]] (Array[]|Function[]|Object[]|string[]): 排序的迭代函数。
3.[orders] (string[]): iteratees迭代函数的排序顺序。
        `,
        return: "(Array): 排序排序后的新数组。",
        case: `
var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 34 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 36 }
];
 
// 以 user 升序排序 再  age 以降序排序。
_.orderBy(users, ['user', 'age'], ['asc', 'desc']);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
        `,
    },
    {
        key: 19,
        name: "partition",
        remark: "按照判断规则将数组内容划分为符合与不符合两个数组",
        use: "_.partition(collection, [predicate=_.identity])",
        description: "创建一个分成两组的元素数组，第一组包含predicate（断言函数）返回为 truthy（真值）的元素，第二组包含predicate（断言函数）返回为 falsey（假值）的元素。predicate 调用1个参数：(value)。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回元素分组后的数组。",
        case: `
var users = [
  { 'user': 'barney',  'age': 36, 'active': false },
  { 'user': 'fred',    'age': 40, 'active': true },
  { 'user': 'pebbles', 'age': 1,  'active': false }
];
 
_.partition(users, function(o) { return o.active; });
// => objects for [['fred'], ['barney', 'pebbles']]
 
// The _.matches iteratee shorthand.
_.partition(users, { 'age': 1, 'active': false });
// => objects for [['pebbles'], ['barney', 'fred']]
 
// The _.matchesProperty iteratee shorthand.
_.partition(users, ['active', false]);
// => objects for [['barney', 'pebbles'], ['fred']]
 
// The _.property iteratee shorthand.
_.partition(users, 'active');
// => objects for [['fred'], ['barney', 'pebbles']]
        `,
    },
    {
        key: 20,
        name: "reduce",
        remark: "遍历集合，每次返回值作为下一次迭代使用，可以用于统计数组值或者对象数组某一属性总计结果",
        use: "_.reduce(collection, [iteratee=_.identity], [accumulator])",
        description: `压缩 collection（集合）为一个值，通过 iteratee（迭代函数）遍历 collection（集合）中的每个元素，每次返回的值会作为下一次迭代使用(注：作为iteratee（迭代函数）的第一个参数使用)。 如果没有提供 accumulator，则 collection（集合）中的第一个元素作为初始值。(注：accumulator参数在第一次迭代的时候作为iteratee（迭代函数）第一个参数使用。) iteratee 调用4个参数：
(accumulator, value, index|key, collection).

lodash 中有许多方法是防止作为其他方法的迭代函数（注：即不能作为iteratee参数传递给其他方法），例如：_.reduce,_.reduceRight, 和_.transform。

受保护的方法有（注：即这些方法不能使用_.reduce,_.reduceRight, 和_.transform作为 iteratee 迭代函数参数）：

assign, defaults, defaultsDeep, includes, merge, orderBy, 和 sortBy`,
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[iteratee=_.identity] (Function): 每次迭代调用的函数。
3.[accumulator] (*): 初始值。
        `,
        return: "(*): 返回累加后的值。",
        case: `
_.reduce([1, 2], function(sum, n) {
  return sum + n;
}, 0);
// => 3

_.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
  (result[value] || (result[value] = [])).push(key);
  return result;
}, {});
// => { '1': ['a', 'c'], '2': ['b'] } (无法保证遍历的顺序)
        `,
    },
    {
        key: 21,
        name: "reduceRight",
        remark: "类似reduce，从右到左遍历",
        use: "_.reduceRight(collection, [iteratee=_.identity], [accumulator])",
        description: "这个方法类似_.reduce ，除了它是从右到左遍历collection（集合）中的元素的。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[iteratee=_.identity] (Function): 每次迭代调用的函数。
3.[accumulator] (*): 初始值。
        `,
        return: "(*): 返回累加后的值。",
        case: `
var array = [[0, 1], [2, 3], [4, 5]];

_.reduceRight(array, function(flattened, other) {
  return flattened.concat(other);
}, []);
// => [4, 5, 2, 3, 0, 1]
        `,
    },
    {
        key: 22,
        name: "reject",
        remark: "集合中删除指定条件项",
        use: "_.reject(collection, [predicate=_.identity])",
        description: "_.filter的反向方法;此方法 返回 predicate（断言函数） 不 返回 truthy（真值）的collection（集合）元素（注释：非真）。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回过滤后的新数组",
        case: `
var users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': true }
];
 
_.reject(users, function(o) { return !o.active; });
// => objects for ['fred']
 
// _.matches 迭代简写
_.reject(users, { 'age': 40, 'active': true });
// => objects for ['barney']
 
// _.matchesProperty 迭代简写
_.reject(users, ['active', false]);
// => objects for ['fred']
 
// _.property 迭代简写
_.reject(users, 'active');
// => objects for ['barney']
        `,
    },
    {
        key: 23,
        name: "sample",
        remark: "获取一个随机元素",
        use: "_.sample(collection)",
        description: "从collection（集合）中获得一个随机元素。",
        argument: `
collection (Array|Object): 要取样的集合。
        `,
        return: "(*): 返回随机元素。",
        case: `
_.sample([1, 2, 3, 4]);
// => 2
        `,
    },
    {
        key: 24,
        name: "sampleSize",
        remark: "随机获取n个元素",
        use: "_.sampleSize(collection, [n=1])",
        description: "从collection（集合）中获得 n 个随机元素。",
        argument: `
1.collection (Array|Object): 要取样的集合。
2.[n=1] (number): 取样的元素个数。
        `,
        return: "(Array): 返回随机元素。",
        case: `
_.sampleSize([1, 2, 3], 2);
// => [3, 1]

_.sampleSize([1, 2, 3], 4);
// => [2, 3, 1]
        `,
    },
    {
        key: 25,
        name: "shuffle",
        remark: "打乱集合创建新数组",
        use: "_.shuffle(collection)",
        description: "创建一个被打乱值的集合。 使用Fisher-Yates shuffle 版本。",
        argument: `
collection (Array|Object): 要打乱的集合。
        `,
        return: "Array): 返回打乱的新数组。",
        case: `
_.shuffle([1, 2, 3, 4]);
// => [4, 1, 3, 2]
        `,
    },
    {
        key: 26,
        name: "size",
        remark: "返回集合长度",
        use: "_.size(collection)",
        description: "返回collection（集合）的长度，如果集合是类数组或字符串，返回其 length ；如果集合是对象，返回其可枚举属性的个数。",
        argument: `
collection (Array|Object): 要检查的集合
        `,
        return: "(number): 返回集合的长度。",
        case: `
_.size([1, 2, 3]);
// => 3

_.size({ 'a': 1, 'b': 2 });
// => 2

_.size('pebbles');
// => 7
        `,
    },
    {
        key: 27,
        name: "some",
        remark: "集合中有一个符合返回true",
        use: "_.some(collection, [predicate=_.identity])",
        description: "通过 predicate（断言函数） 检查collection（集合）中的元素是否存在 任意 truthy（真值）的元素，一旦 predicate（断言函数） 返回 truthy（真值），遍历就停止。 predicate 调用3个参数：(value, index|key, collection)。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(boolean): 如果任意元素经 predicate 检查都为 truthy（真值），返回 true ，否则返回 false 。",
        case: `
_.some([null, 0, 'yes', false], Boolean);
// => true
 
var users = [
  { 'user': 'barney', 'active': true },
  { 'user': 'fred',   'active': false }
];
 
// The _.matches iteratee shorthand.
_.some(users, { 'user': 'barney', 'active': false });
// => false
 
// The _.matchesProperty iteratee shorthand.
_.some(users, ['active', false]);
// => true
 
// The _.property iteratee shorthand.
_.some(users, 'active');
// => true
        `,
    },
    {
        key: 28,
        name: "sortBy",
        remark: "对集合执行处理，以处理结果进行排序",
        use: "_.sortBy(collection, [iteratees=[_.identity]])",
        description: "创建一个元素数组。 以 iteratee 处理的结果升序排序。 这个方法执行稳定排序，也就是说相同元素会保持原始排序。 iteratees 调用1个参数： (value)。",
        argument: `
1.collection (Array|Object): 用来迭代的集合。
2.[iteratees=[_.identity]] (...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])): 这个函数决定排序。
        `,
        return: "(Array): 返回排序后的数组。",
        case: `
var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];

_.sortBy(users, function(o) { return o.user; });
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

_.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]

_.sortBy(users, 'user', function(o) {
  return Math.floor(o.age / 10);
});
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
        `,
    },
];
